Bembidion_Population_Manager Class Reference

The population manager class for beetles. More...

#include <bembidion_all.h>

Inheritance diagram for Bembidion_Population_Manager:

Public Member Functions
void	CreateObjects (int ob_type, TAnimal *pvo, void *null, struct_Bembidion *data, int number)
	Method to add beetles to the population. More...
virtual void	Init (void)
	Intialises the population manager. More...
virtual void	DoFirst (void)
	Does day degree development calculations here. More...
virtual void	DoBefore (void)
	Replaces the Step function for the Egg_List. More...
virtual void	DoAlmostLast (void)
	Removes dead or pupated larvae from the simulation. More...
virtual void	DoLast (void)
	Adds output adult locations to DoLast. More...
virtual float	Probe (int ListIndex, probe_data *p_TheProbe)
	Overides the Population_Manager::Probe method. More...
	Bembidion_Population_Manager (Landscape *p_L)
	Constructor. More...
virtual	~Bembidion_Population_Manager ()
	Destructor. More...
int	SupplyAdPopSize ()
	Get adult population size. More...
int	SupplyEggPopSize ()
	Get egg population size. More...
int	SupplyLarvaePopSize ()
	Get larval population size. More...
int	SupplyPupaePopSize ()
	Get pupal population size. More...
double	SupplyEDayDeg (int day)
	Get egg day degress for a specific day. More...
double	SupplyLDayDeg (int L, int day)
	Get larval day degress for a specific dayand instar. More...
double	SupplyPDayDeg (int day)
	Get pupal day degress for a specific day. More...
Public Member Functions inherited from Population_Manager
	Population_Manager (Landscape *L)
virtual	~Population_Manager (void)
void	SetNoProbes (int a_pn)
unsigned	GetLiveArraySize (int a_listindex)
	Gets the number of 'live' objects for a list index in the TheArray. More...
void	IncLiveArraySize (int a_listindex)
	Increments the number of 'live' objects for a list index in the TheArray. More...
virtual void	Catastrophe (int)
unsigned int	FarmAnimalCensus (unsigned int a_farm, unsigned int a_typeofanimal)
char *	SpeciesSpecificReporting (int a_species, int a_time)
char *	ProbeReport (int a_time)
char *	ProbeReportTimed (int a_time)
void	ImpactProbeReport (int a_Time)
bool	BeginningOfMonth ()
void	LOG (const char *fname)
int	SupplyStepSize ()
int	SupplySimW ()
int	SupplySimH ()
virtual void	Run (int NoTSteps)
virtual void	ImpactedProbe ()
int	SupplyListNameLength ()
TAnimal *	SupplyAnimalPtr (int a_index, int a_animal)
	Returns the pointer indexed by a_index and a_animal. Note NO RANGE CHECK. More...
unsigned	SupplyListIndexSize ()
unsigned	SupplyListSize (unsigned listindex)
bool	CheckXY (int l, int i)
	Debug method to test for out of bounds coordinates. More...
const char *	SupplyListName (int i)
bool	IsLast (unsigned listindex)
int	SupplyState (unsigned listindex, unsigned j)
virtual void	SupplyLocXY (unsigned listindex, unsigned j, int &x, int &y)
const char *	SupplyStateNames (int i)
unsigned	SupplyStateNamesLength ()
virtual void	DisplayLocations ()
int	ProbeFileInput (char *p_Filename, int p_ProbeNo)
TAnimal *	FindClosest (int x, int y, unsigned Type)
bool	OpenTheRipleysOutputProbe (string a_NWordFilename)
void	OpenTheAOROutputProbe (string a_AORFilename)
bool	OpenTheMonthlyRipleysOutputProbe ()
bool	OpenTheReallyBigProbe ()
void	CloseTheMonthlyRipleysOutputProbe ()
virtual void	CloseTheRipleysOutputProbe ()
virtual void	CloseTheReallyBigOutputProbe ()
TTypesOfPopulation	GetPopulationType ()
int	GetSeasonNumber ()
	Get the season number. More...
void	LamdaDeath (int x, int y)
void	LamdaBirth (int x, int y)
void	LamdaBirth (int x, int y, int z)
void	LamdaClear ()
void	LamdaDumpOutput ()
virtual int	SupplyPegPosx (int)
virtual int	SupplyPegPosy (int)
virtual int	SupplyCovPosx (int)
virtual int	SupplyCovPosy (int)
virtual bool	OpenTheFledgelingProbe ()
virtual bool	OpenTheBreedingPairsProbe ()
virtual bool	OpenTheBreedingSuccessProbe ()
virtual void	BreedingPairsOutput (int)
virtual int	TheBreedingFemalesProbe (int)
virtual int	TheFledgelingProbe ()
virtual void	BreedingSuccessProbeOutput (double, int, int, int, int, int, int, int)
virtual int	TheBreedingSuccessProbe (int &, int &, int &, int &, int &, int &)
virtual void	FledgelingProbeOutput (int, int)
virtual void	TheGeneticProbe (unsigned, int, unsigned &)
virtual void	GeneticsResultsOutput (FILE *, unsigned)

Public Attributes
MovementMap *	m_MoveMap
	Map of suitability for movement. More...
SimplePositionMap *	m_LarvaePosMap
	Optimised map of larval positions. More...
SimplePositionMap *	m_AdultPosMap
	Optimsied map of adult positions. More...
int	LDDepMort0
	Storage for density-dependent mortality parameter. More...
double	LDDepMort1
	Storage for density-dependent mortality parameter. More...
int	ADDepMort0
	Storage for density-dependent mortality parameter. More...
double	ADDepMort1
	Storage for density-dependent mortality parameter. More...
int	TodaysEggProduction
	Daily temperature determined egg production. More...
Bembidion_Egg_List *	m_EList [365]
	Replacement for TheArray[0]. More...
Public Attributes inherited from Population_Manager
int	IndexArrayX [5][10000]
probe_data *	TheProbe [100]
int	SimH
int	SimW
unsigned	SimHH
unsigned	SimWH
char	m_SimulationName [255]
bool	ProbesSet
Landscape *	m_TheLandscape

Protected Member Functions
virtual void	Catastrophe ()
	Method to arbitrarily alter populations size. More...
virtual void	TheRipleysOutputProbe (FILE *a_prb)
	Special output functionality. More...
virtual void	TheReallyBigOutputProbe ()
	Special output functionality. More...
virtual void	TheAOROutputProbe ()
	Special output functionality. More...
bool	IsStartHabitat (int a_x, int a_y)
	Used to specify legal starting habitats for simulation start-up. More...
Protected Member Functions inherited from Population_Manager
virtual bool	StepFinished ()
	Overrides the population manager StepFinished - there is no chance that hunters do not finish a step behaviour. More...
virtual void	DoAfter ()
void	EmptyTheArray ()
	Removes all objects from the TheArray by deleting them and clearing TheArray. More...
void	SortX (unsigned Type)
void	SortXIndex (unsigned Type)
void	SortY (unsigned Type)
void	SortState (unsigned Type)
void	SortStateR (unsigned Type)
unsigned	PartitionLiveDead (unsigned Type)
void	Shuffle_or_Sort (unsigned Type)
void	Shuffle (unsigned Type)

Protected Attributes
Landscape *	The_Landscape
	Pointer to the landscape. More...
int	m_AdPopSize
	To store the current population size. More...
int	m_EPopSize
	To store the current population size. More...
int	m_LPopSize
	To store the current population size. More...
int	m_PPopSize
	To store the current population size. More...
double	m_EDayDeg [365]
	Storage for daily day degrees for eggs. More...
double	m_LDayDeg [365][3]
	Storage for daily day degrees for larve. More...
double	m_PDayDeg [365]
	Storage for daily day degrees for pupae. More...
Protected Attributes inherited from Population_Manager
vector< unsigned >	m_LiveArraySize
int	m_NoProbes
AOR_Probe *	m_AOR_Probe
FILE *	m_GeneticsFile
FILE *	m_AlleleFreqsFile
FILE *	m_EasyPopRes
const char *	StateNames [100]
int	m_catastrophestartyear
int	m_StepSize
vector< TListOfAnimals >	TheArray
unsigned	StateNamesLength
const char *	m_ListNames [32]
unsigned	m_ListNameLength
FILE *	TestFile
FILE *	TestFile2
unsigned	BeforeStepActions [12]
int	m_SeasonNumber
	Holds the season number. Used when running goose and hunter sims. More...
TTypesOfPopulation	m_population_type
ofstream *	AOROutputPrb
FILE *	RipleysOutputPrb
FILE *	RipleysOutputPrb1
FILE *	RipleysOutputPrb2
FILE *	RipleysOutputPrb3
FILE *	RipleysOutputPrb4
FILE *	RipleysOutputPrb5
FILE *	RipleysOutputPrb6
FILE *	RipleysOutputPrb7
FILE *	RipleysOutputPrb8
FILE *	RipleysOutputPrb9
FILE *	RipleysOutputPrb10
FILE *	RipleysOutputPrb11
FILE *	RipleysOutputPrb12
FILE *	ReallyBigOutputPrb
long int	lamdagrid [2][257][257]

Detailed Description

The population manager class for beetles.

Constructor & Destructor Documentation

Bembidion_Population_Manager()

Bembidion_Population_Manager::Bembidion_Population_Manager

(

Landscape *

p_L

)

Constructor.

   : Population_Manager(p_L)
{
  // Four lists are needed so need to remove 6 of the ten default arrays
  // Eggs, Larvae, Pupae & Adults
  for (int i=0; i<4; i++)
  {
    TheArray.pop_back();
  }
  m_MoveMap=new MovementMap(p_L, 0); // 0 for beetles
  m_LarvaePosMap=new SimplePositionMap(p_L);
  m_AdultPosMap=new SimplePositionMap(p_L);
// Create the egg lists
  for (int i=0; i<365; i++)
  {
    m_EList[i]=new Bembidion_Egg_List(i,this,p_L);
 
  }
  // Clear the m_DayDeg array
  for (int i=0; i<365; i++)
  {
    m_EDayDeg[i]=0;
    m_LDayDeg[i][0]=0;
    m_LDayDeg[i][1]=0;
    m_LDayDeg[i][2]=0;
    m_PDayDeg[i]=0;
  }
  MaxDailyMovement=cfg_MaxDailyMovement.value();
  LDDepMort0=cfg_LDDepMort0.value();
  LDDepMort1=cfg_LDDepMort1.value()/100.0;
  ADDepMort0=cfg_ADDepMort0.value();
  ADDepMort1=cfg_ADDepMort1.value()/100.0;
  TodaysEggProduction=0;
  Init();
}

References ADDepMort0, ADDepMort1, cfg_ADDepMort0, cfg_ADDepMort1, cfg_LDDepMort0, cfg_LDDepMort1, cfg_MaxDailyMovement, Init(), LDDepMort0, LDDepMort1, m_AdultPosMap, m_EDayDeg, m_EList, m_LarvaePosMap, m_LDayDeg, m_MoveMap, m_PDayDeg, MaxDailyMovement, Population_Manager::TheArray, TodaysEggProduction, and CfgInt::value().

~Bembidion_Population_Manager()

Bembidion_Population_Manager::~Bembidion_Population_Manager ( )

virtual

Destructor.

{
  for (int i=0; i<365; i++) delete m_EList[i];
  delete m_MoveMap;
  delete m_LarvaePosMap;
  delete m_AdultPosMap;
}

References m_AdultPosMap, m_EList, m_LarvaePosMap, and m_MoveMap.

Member Function Documentation

Catastrophe()

void Bembidion_Population_Manager::Catastrophe ( void  )

protectedvirtual

Method to arbitrarily alter populations size.

This method simply alters populations on 1st January - either by increasing or decreasing them. Increases are by 'cloning', decrease by pro-rata mortality. The effect is under the control of configuration variables cfg_pm_eventfrequency and cfg_pm_eventsize.

Reimplemented from Population_Manager.

                                                     {
 
    // First do we have the right day?
    int today = m_TheLandscape->SupplyDayInYear();
    if (today!=1) return;
    // First do we have the right year?
    int year = m_TheLandscape->SupplyYearNumber()-m_catastrophestartyear;
    if (year%cfg_pm_eventfrequency.value()!=0) return;
 
    Bembidion_Adult* BA = NULL;
    // Now if the % decrease is higher or lower than 100 we need to do different things
    int esize=cfg_pm_eventsize.value();
    if (esize<100) {
        unsigned size2;
        size2 = (unsigned)GetLiveArraySize( bob_Adult );
            for ( unsigned j = 0; j < size2; j++ ) {
                if (random(100) > esize) {
                        BA = dynamic_cast < Bembidion_Adult * > ( TheArray[ bob_Adult ] [ j ] );
                        BA->CurrentBState=tobs_ADying; // Kill it
                }
            }
        }
    else if (esize>100) {
        // This also requires a copy method in the target animals
        // esize also needs translating  120 = 20%, 200 = 100%
        if (esize<200) {
            esize-=100;
            unsigned size2;
            size2 = (unsigned)GetLiveArraySize( bob_Adult );
            for ( unsigned j = 0; j < size2; j++ ) {
                if (random(100) < esize) {
                        BA = dynamic_cast < Bembidion_Adult * > ( TheArray[ bob_Adult ] [ j ] );
                        BA->CopyMyself(bob_Adult); // Duplicate it
                    }
                }
        } else {
            esize-=100;
            esize/=100; // this will throw away fractional parts so will get 1, 2, 3  from 200, 350 400
                unsigned size2;
                size2 = (unsigned)GetLiveArraySize( bob_Adult );
                for ( unsigned j = 0; j < size2; j++ ) {
                    for ( int e=0; e<esize; e++) {
                        BA = dynamic_cast < Bembidion_Adult * > (TheArray[bob_Adult][j]);
                        BA->CopyMyself(bob_Adult); // Duplicate it
                        }
                }
            }
        }
    else return; // No change so do nothing
}

References bob_Adult, cfg_pm_eventfrequency, cfg_pm_eventsize, Bembidion_Base::CopyMyself(), Bembidion_Base::CurrentBState, Population_Manager::GetLiveArraySize(), Population_Manager::m_catastrophestartyear, Population_Manager::m_TheLandscape, random(), Landscape::SupplyDayInYear(), Landscape::SupplyYearNumber(), Population_Manager::TheArray, tobs_ADying, and CfgInt::value().

CreateObjects()

void Bembidion_Population_Manager::CreateObjects	(	int	ob_type,
		TAnimal *	pvo,
		void *	null,
		struct_Bembidion *	data,
		int	number
	)

Method to add beetles to the population.

All bembidion objects that are created must be created using this method. Data on the location and other attributes are passed in data, and the number to create in number.

{
   Bembidion_Adult*  new_Adult;
   Bembidion_Pupae*  new_Pupa;
   Bembidion_Larvae* new_Larva;
 
   for (int i=0; i<number; i++)
   {
    if (ob_type == 0)
    {
      m_EList[data->L->SupplyDayInYear()]->AddEgg(data->x, data->y);
    }
    if (ob_type == 1) {
        // Will not create a new larva in a square already occupied
        if (m_LarvaePosMap->GetMapValue( data->x, data->y ) == 0) {
            m_LarvaePosMap->SetMapValue( data->x, data->y );
            if (unsigned(TheArray[ob_type].size())>GetLiveArraySize(ob_type )) {
                // We need to reuse an object
                dynamic_cast<Bembidion_Larvae*>(TheArray[ob_type][GetLiveArraySize(ob_type) ])->ReInit(data->x, data->y, data->L, this);
                IncLiveArraySize(ob_type);
            }
            else {
                new_Larva = new Bembidion_Larvae( data->x, data->y, data->L, this );
                //TheArray[ ob_type ].insert( TheArray[ ob_type ].begin(), new_Larva );
                TheArray[ ob_type ].push_back( new_Larva );
                IncLiveArraySize(ob_type);
            }
        }
    }
    if (ob_type == 2)
    {
        if (unsigned(TheArray[ob_type].size())>GetLiveArraySize(ob_type)) {
            // We need to reuse an object
            dynamic_cast<Bembidion_Pupae*>(TheArray[ob_type][GetLiveArraySize(ob_type)])->ReInit(data->x, data->y, data->L, this);
            IncLiveArraySize(ob_type);
        }
        else {
            new_Pupa = new Bembidion_Pupae( data->x, data->y, data->L, this );
            TheArray[ ob_type ].push_back( new_Pupa );
            IncLiveArraySize(ob_type);
        }
    }
    if (ob_type == 3)
    {
        if (unsigned(TheArray[ob_type].size())>GetLiveArraySize(ob_type)) {
            // We need to reuse an object
            dynamic_cast<Bembidion_Adult*>(TheArray[ob_type][GetLiveArraySize(ob_type)])->ReInit(data->x, data->y, data->L, this);
            IncLiveArraySize(ob_type);
        }
        else {
            new_Adult = new Bembidion_Adult( data->x, data->y, data->L, this );
            TheArray[ ob_type ].push_back( new_Adult );
            IncLiveArraySize(ob_type);
        }
    }
   }
}

References Bembidion_Egg_List::AddEgg(), Population_Manager::GetLiveArraySize(), SimplePositionMap::GetMapValue(), Population_Manager::IncLiveArraySize(), struct_Bembidion::L, m_EList, m_LarvaePosMap, SimplePositionMap::SetMapValue(), Landscape::SupplyDayInYear(), Population_Manager::TheArray, struct_Bembidion::x, and struct_Bembidion::y.

Referenced by Bembidion_Base::CopyMyself(), Bembidion_Base::CopyMyselfB(), Init(), Bembidion_Adult::Reproduce(), Bembidion_Pupae::st_Emerge(), Bembidion_Egg_List::st_Hatch(), and Bembidion_Larvae::st_Pupate().

DoAlmostLast()

void Bembidion_Population_Manager::DoAlmostLast ( void  )

virtual

Removes dead or pupated larvae from the simulation.

This sorts the larval list according to state, then removes the dead ones. This is a little faster than leaving the job to the default population manager functionality.

Reimplemented from Population_Manager.

{
}

DoBefore()

void Bembidion_Population_Manager::DoBefore ( void  )

virtual

Replaces the Step function for the Egg_List.

Reimplemented from Population_Manager.

{
  // This replaces the step function for the eggs
  for (int i=0; i<365; i++) m_EList[i]->SetStepDone(false);
  for (int i=0; i<365; i++) m_EList[i]->Step();
 
}

References m_EList.

DoFirst()

void Bembidion_Population_Manager::DoFirst ( void  )

virtual

Does day degree development calculations here.

This method removes any young stages that have survived until winter.
It subsequently calculates day degree development for each day for each beetle stage. This is an optimising strategy to prevent each beetle individual calculating these.
Finally it replaces the Egg_List BeginStep functionality. This is also an optimisation since it only requires 365 Egg_lists, one for each day of the year instead of millions of individual eggs.
NB this breaks the traditional ALMaSS protocol for handling animal individuals.

Reimplemented from Population_Manager.

{
#ifdef __RECORD_RECOVERY_POLYGONS
    RecordRecoveryPolygons();
#endif
  int today=m_TheLandscape->SupplyDayInYear();
  // WHOOAA!! This is really dangerous if these objects are registered anywhere
  // else in the system
  if (today==364)
  {
      for (unsigned j = 0; j<GetLiveArraySize( bob_Egg ); j++)
    {
      TheArray[bob_Egg][j]->KillThis(); // Destroy this
    }
      for (unsigned j = 0; j<GetLiveArraySize( bob_Larva ); j++)
    {
      TheArray[bob_Larva][j]->KillThis(); // Destroy this
    }
      for (unsigned j = 0; j<GetLiveArraySize( bob_Pupa ); j++)
    {
      TheArray[bob_Pupa][j]->KillThis(); // Destroy this
    }
  }
  else if (today==0)
  {
   for (int i=0; i<365; i++)
   {
     m_EList[i]->EggList.clear();
     m_EDayDeg[i]=0;
     m_LDayDeg[i][0]=0;
     m_LDayDeg[i][1]=0;
     m_LDayDeg[i][2]=0;
     m_PDayDeg[i]=0;
   }
  }
 
  double temptoday=m_TheLandscape->SupplyTemp();
  // Calculate the number of eggs laid today
  if (temptoday>AdultEggLayingThreshold)
    TodaysEggProduction=(int) floor(0.5+(((double)temptoday-
                          (double)AdultEggLayingThreshold)*EggProductionSlope));
  else TodaysEggProduction=0;
  if (TodaysEggProduction>10)TodaysEggProduction=10; // ensure no bigger than 10
  // Calculated the DayDegrees for the different stages today
  if (temptoday>DevelConst1)
  {
   temptoday-=DevelConst1; // Subtract the threshold
   if (temptoday>DevelopmentInflectionPoint)
   {
    for(int i=0; i<=today; i++)
    {
      double et,l1t,l2t,l3t,pt;
      et=temptoday*above12Egg;
      l1t=temptoday*above12Larvae[0];
      l2t=temptoday*above12Larvae[1];
      l3t=temptoday*above12Larvae[2];
      pt=temptoday*above12Pupae;
      m_EDayDeg[i]+=et;
      m_LDayDeg[i][0]+=l1t;
      m_LDayDeg[i][1]+=l2t;
      m_LDayDeg[i][2]+=l3t;
      m_PDayDeg[i] += pt;
    }
   }
   else
   {
    for(int i=0; i<=today; i++)
    {
      m_EDayDeg[i]+=temptoday;
      m_LDayDeg[i][0]+=temptoday;
      m_LDayDeg[i][1]+=temptoday;
      m_LDayDeg[i][2]+=temptoday;
      m_PDayDeg[i]+=temptoday;
    }
   }
  }
  // Store the current population sizes
  m_EPopSize = (int)GetLiveArraySize( bob_Egg );
  m_LPopSize = (int)GetLiveArraySize( bob_Larva );
  m_PPopSize = (int)GetLiveArraySize( bob_Pupa );
  m_AdPopSize = (int)GetLiveArraySize( bob_Adult);
 
#ifdef __LAMBDA_RECORD
  if (today==March) {
      LamdaDumpOutput();
      LamdaClear();
  }
#endif
 
#ifdef __BEETLEPESTICIDE1
  if (today==0) PestMortLocOutput();
#endif
 
  // This replaces the BeginStep function for the eggs
  for (int i=0; i<365; i++)
  {
    m_EList[i]->BeginStep();
  }
}

References above12Egg, above12Larvae, above12Pupae, AdultEggLayingThreshold, Bembidion_Egg_List::BeginStep(), bob_Adult, bob_Egg, bob_Larva, bob_Pupa, DevelConst1, DevelopmentInflectionPoint, Bembidion_Egg_List::EggList, EggProductionSlope, Population_Manager::GetLiveArraySize(), Population_Manager::LamdaClear(), Population_Manager::LamdaDumpOutput(), m_AdPopSize, m_EDayDeg, m_EList, m_EPopSize, m_LDayDeg, m_LPopSize, m_PDayDeg, m_PPopSize, Population_Manager::m_TheLandscape, March, Landscape::SupplyDayInYear(), Landscape::SupplyTemp(), Population_Manager::TheArray, and TodaysEggProduction.

DoLast()

void Bembidion_Population_Manager::DoLast ( void  )

virtual

Adds output adult locations to DoLast.

Outputs the adult locations if needed

Reimplemented from Population_Manager.

{
    Population_Manager::DoLast();
#ifdef __BEETLEPESTICIDE1
    int today=m_TheLandscape->SupplyDayInYear();
    if (cfg_SaveInfieldLocation.value()) 
    {
        if (today>=cfg_SaveInfieldLocationStartDay.value())
        {
            if (cfg_SaveInfieldLocationStartDay.value() == -2) 
            {
                if (m_TheLandscape->SupplyDayInMonth() == 1) DoInFieldLocationOutput();
            }
            else
            {
                if ( (today - cfg_SaveInfieldLocationStartDay.value()) % cfg_SaveInfieldLocationInterval.value() == 0) DoInFieldLocationOutput();
            }
        }
    }
#endif
}

References cfg_SaveInfieldLocation, cfg_SaveInfieldLocationInterval, cfg_SaveInfieldLocationStartDay, Population_Manager::DoLast(), Population_Manager::m_TheLandscape, Landscape::SupplyDayInMonth(), Landscape::SupplyDayInYear(), CfgInt::value(), and CfgBool::value().

Init()

void Bembidion_Population_Manager::Init ( void  )

virtual

Intialises the population manager.

Initialises the population manager and creates the initial beetle population.
Housekeeping actions such as setting up probe files and recording life-stage and state names are done here.
An optimisation is to sort the larval list by x-coordinate to speed searching later. This removes the default randomising function for larvae.

{
 
 // autom. called by constructor
    if (cfg_RipleysOutput_used.value()) {
        OpenTheRipleysOutputProbe("");
    }
    if ( cfg_ReallyBigOutput_used.value() ) {
    OpenTheReallyBigProbe();
  } else ReallyBigOutputPrb=0;
 strcpy(m_SimulationName,"Bembidion");
 // Create cfg_beetlestartnos adults
 struct_Bembidion* aps;
 aps = new struct_Bembidion;
 aps->BPM = this;
 aps->L = m_TheLandscape;
 for (int i=0; i<cfg_beetlestartnos.value(); i++)
 {
   do
   {
     aps->x = random(m_TheLandscape->SupplySimAreaWidth());
     aps->y = random(m_TheLandscape->SupplySimAreaHeight());
   } while (!IsStartHabitat(aps->x, aps->y));
   CreateObjects(3,NULL,NULL,aps,1);
 }
 delete aps;
 m_AdPopSize=cfg_beetlestartnos.value();
 m_EPopSize=0;
 m_LPopSize=0;
 m_PPopSize=0;
 
// Load List of Animal Classes
  m_ListNames[0]="Egg";
  m_ListNames[1]="Larva";
  m_ListNames[2]="Pupa";
  m_ListNames[3]="Adult";
  m_ListNameLength = 4;
  m_population_type = TOP_Beetle;
 
// Load State Names
  StateNames[tobs_Initiation] = "Initiation";
//Egg
  StateNames[tobs_EDeveloping] = "Developing";
  StateNames[tobs_Hatching] = "Hatching";
  StateNames[tobs_EDying] = "Dying";
//Larva
  StateNames[tobs_LDeveloping] = "Developing";
  StateNames[tobs_Pupating] = "Pupating";
  StateNames[tobs_LDying] = "Dying";
//Pupa
  StateNames[tobs_PDeveloping] = "Developing";
  StateNames[tobs_Emerging] = "Emerging";
  StateNames[tobs_PDying] = "Dying";
//Adult
  StateNames[tobs_Foraging] = "Foraging";
  StateNames[tobs_Aggregating] = "Aggregating";
  StateNames[tobs_Hibernating] = "Hibernating";
  StateNames[tobs_Dispersing] = "Dispersing";
  StateNames[tobs_ADying] = "Dying";
 
  // Ensure that larvae are sorted w.r.t. x position not shuffled
  BeforeStepActions[1]=1; // 1 = SortX
 
#ifdef __RECORD_RECOVERY_POLYGONS
    /* Open the output file and append */
    ofstream ofile("RecoveryPolygonsCounter.txt",ios::out);
    ofile << "This file records the number of females in each polygon each day" << endl;
    ofile.close();
    /* Open the polygon recovery file and read in polygons to m_RecoveryPolygons */
    ifstream ifile("RecoveryPolygonsList.txt",ios::in);
    int n;
    ifile >> n;
    m_RecoveryPolygons[0] = n;
    for (int i=0; i<n; i++) ifile >> m_RecoveryPolygons[1+i];
    for (int i=0; i<n; i++) m_RecoveryPolygonsC[1+i]=0;
    ifile.close();
#endif
 
#ifdef __BEETLEPESTICIDE1
    PestMortLocOutputOpen();
    m_InFieldNo = 0;
    m_OffFieldNo = 0;
    m_InCropNo = 0;
    m_InCropRef = m_TheLandscape->TranslateVegTypes(cfg_InCropRef.value());
    if (cfg_SaveInfieldLocation.value()) LocOutputOpen();
#endif
    Bembidion_Adult ba(0,0,NULL,NULL);
 
    // Initialise any static variables
    ba.SetAdultPPPElimRate(cfg_BemAdultPPPElimiationRate.value());  // Initialize static variable
    ba.SetPPPThreshold(cfg_BemAdultPPPThreshold.value());  // Initialize static variable
    ba.SetPPPEffectProb(cfg_BemAdultPPPEffectProb.value());  // Initialize static variable
    ba.SetPPPEffectProbDecay(cfg_BemAdultPPPEffectProbDecay.value());  // Initialize static variable
}

References Population_Manager::BeforeStepActions, struct_Bembidion::BPM, cfg_beetlestartnos, cfg_BemAdultPPPEffectProb, cfg_BemAdultPPPEffectProbDecay, cfg_BemAdultPPPElimiationRate, cfg_BemAdultPPPThreshold, cfg_InCropRef, cfg_ReallyBigOutput_used, cfg_RipleysOutput_used, cfg_SaveInfieldLocation, CreateObjects(), IsStartHabitat(), struct_Bembidion::L, m_AdPopSize, m_EPopSize, Population_Manager::m_ListNameLength, Population_Manager::m_ListNames, m_LPopSize, Population_Manager::m_population_type, m_PPopSize, Population_Manager::m_SimulationName, Population_Manager::m_TheLandscape, Population_Manager::OpenTheReallyBigProbe(), Population_Manager::OpenTheRipleysOutputProbe(), random(), Population_Manager::ReallyBigOutputPrb, Bembidion_Adult::SetAdultPPPElimRate(), Bembidion_Adult::SetPPPEffectProb(), Bembidion_Adult::SetPPPEffectProbDecay(), Bembidion_Adult::SetPPPThreshold(), Population_Manager::StateNames, Landscape::SupplySimAreaHeight(), Landscape::SupplySimAreaWidth(), tobs_ADying, tobs_Aggregating, tobs_Dispersing, tobs_EDeveloping, tobs_EDying, tobs_Emerging, tobs_Foraging, tobs_Hatching, tobs_Hibernating, tobs_Initiation, tobs_LDeveloping, tobs_LDying, tobs_PDeveloping, tobs_PDying, tobs_Pupating, TOP_Beetle, Landscape::TranslateVegTypes(), CfgInt::value(), CfgFloat::value(), CfgBool::value(), struct_Bembidion::x, and struct_Bembidion::y.

Referenced by Bembidion_Population_Manager().

IsStartHabitat()

bool Bembidion_Population_Manager::IsStartHabitat ( int  a_x, int  a_y  )

protected

Used to specify legal starting habitats for simulation start-up.

{
    TTypesOfLandscapeElement tole;
    tole=m_TheLandscape->SupplyElementType(a_x, a_y);
    switch(tole)
    {
      case tole_Field:
      case tole_Orchard:
      case tole_PermPasture:
      case tole_PermPastureLowYield:
      case tole_PermPastureTussocky:
      case tole_RoadsideVerge:
      case tole_NaturalGrassDry:
      case tole_NaturalGrassWet:
      case tole_FieldBoundary:
      case tole_UnsprayedFieldMargin:
      case tole_YoungForest:
      case tole_WaterBufferZone:
          return true;
      default:
          return false;
    }
}

References Population_Manager::m_TheLandscape, Landscape::SupplyElementType(), tole_Field, tole_FieldBoundary, tole_NaturalGrassDry, tole_NaturalGrassWet, tole_Orchard, tole_PermPasture, tole_PermPastureLowYield, tole_PermPastureTussocky, tole_RoadsideVerge, tole_UnsprayedFieldMargin, tole_WaterBufferZone, and tole_YoungForest.

Referenced by Init().

Probe()

float Bembidion_Population_Manager::Probe ( int  ListIndex, probe_data *  p_TheProbe  )

virtual

Overides the Population_Manager::Probe method.

The parent class Probe method needs to be overridden because of the use of the Egg_List class. Otherwise functionality is the same as parent class.

Reimplemented from Population_Manager.

{
  // Counts through the list and goes through each area to see if the animal
  // is standing there and if the farm, veg or element conditions are met
  AnimalPosition Sp;
  float NumberSk = 0;
  if (ListIndex==0)
  {
     unsigned X;
     unsigned Y;
     // Four possibilites
     // either NoVegTypes or NoElementTypes or NoFarmTypes is >0 or all==0
     if (p_TheProbe->m_NoFarms!=0)
     {
       for (int n=0; n<365; n++)
       {
        for (unsigned j=0; j<m_EList[n]->EggList.size(); j++)
        {
         Y=m_EList[n]->EggList[j].m_y;
         X=m_EList[n]->EggList[j].m_x;
         unsigned Farm=m_TheLandscape->SupplyFarmOwner(X,Y);
         for (unsigned i=0; i<p_TheProbe->m_NoAreas; i++)
         {
           if ((X>=p_TheProbe->m_Rect[i].m_x1)
            && (Y>=p_TheProbe->m_Rect[i].m_y1)
            && (X<=p_TheProbe->m_Rect[i].m_x2)
            && (Y<=p_TheProbe->m_Rect[i].m_y2))
              for (unsigned k=0; k<p_TheProbe->m_NoFarms; k++)
              {
                if (p_TheProbe->m_RefFarms[k]==Farm)
                NumberSk++; // it is in the square so increment number
              }
         }
        }
       }
     }
     else if (p_TheProbe->m_NoEleTypes!=0)
     {
       for (int n=0; n<365; n++)
       {
        for (unsigned j=0; j<m_EList[n]->EggList.size(); j++)
        {
         Y=m_EList[n]->EggList[j].m_y;
         X=m_EList[n]->EggList[j].m_x;
         int EleType = (int)m_TheLandscape->SupplyElementType(X,Y);
         for (unsigned i=0; i<p_TheProbe->m_NoAreas; i++)
         {
           if ((X>=p_TheProbe->m_Rect[i].m_x1)
            && (Y>=p_TheProbe->m_Rect[i].m_y1)
            && (X<=p_TheProbe->m_Rect[i].m_x2)
            && (Y<=p_TheProbe->m_Rect[i].m_y2))
              for (unsigned k=0; k<p_TheProbe->m_NoEleTypes; k++)
              {
                if (p_TheProbe->m_RefEle[k]==EleType)
                NumberSk++; // it is in the square so increment number
              }
         }
        }
       }
     }
     else if (p_TheProbe->m_NoVegTypes!=0)
     {
       for (int n=0; n<365; n++)
       {
        for (unsigned j=0; j<m_EList[n]->EggList.size(); j++)
        {
         Y=m_EList[n]->EggList[j].m_y;
         X=m_EList[n]->EggList[j].m_x;
         int VegType = (int)m_TheLandscape->SupplyVegType(X,Y);
         for (unsigned i=0; i<p_TheProbe->m_NoAreas; i++)
         {
           if ((X>=p_TheProbe->m_Rect[i].m_x1)
            && (Y>=p_TheProbe->m_Rect[i].m_y1)
            && (X<=p_TheProbe->m_Rect[i].m_x2)
            && (Y<=p_TheProbe->m_Rect[i].m_y2))
               for (unsigned k=0; k<p_TheProbe->m_NoVegTypes; k++)
               {
                 if (p_TheProbe->m_RefVeg[k]==VegType)
                    NumberSk++; // it is in the square so increment number
               }
             }
           }
         }
     }
     else // both must be zero
     {
         for (int n=0; n<365; n++)
         {
           for (unsigned j=0; j<m_EList[n]->EggList.size(); j++)
           {
             Y=m_EList[n]->EggList[j].m_y;
             X=m_EList[n]->EggList[j].m_x;
             for (unsigned i=0; i<p_TheProbe->m_NoAreas; i++)
             {
               if ((X>=p_TheProbe->m_Rect[i].m_x1)
                && (Y>=p_TheProbe->m_Rect[i].m_y1)
                && (X<=p_TheProbe->m_Rect[i].m_x2)
                && (Y<=p_TheProbe->m_Rect[i].m_y2))
                  NumberSk++; // it is in the square so increment number
 
             }
           }
         }
      }
  }
  else
  {
     // Four possibilites
     // either NoVegTypes or NoElementTypes or NoFarmTypes is >0 or all==0
     if (p_TheProbe->m_NoFarms!=0)
     {
         for (unsigned j = 0; j<GetLiveArraySize( ListIndex ); j++)
       {
         Sp=TheArray[ListIndex][j]->SupplyPosition();
         unsigned Farm=TheArray[ListIndex][j]->SupplyFarmOwnerRef();
         for (unsigned i=0; i<p_TheProbe->m_NoAreas; i++)
         {
           if ((Sp.m_x>=p_TheProbe->m_Rect[i].m_x1)
            && (Sp.m_y>=p_TheProbe->m_Rect[i].m_y1)
            && (Sp.m_x<=p_TheProbe->m_Rect[i].m_x2)
            && (Sp.m_y<=p_TheProbe->m_Rect[i].m_y2))
              for (unsigned k=0; k<p_TheProbe->m_NoFarms; k++)
              {
                if (p_TheProbe->m_RefFarms[k]==Farm)
                NumberSk++; // it is in the square so increment number
              }
         }
       }
     }
     else if (p_TheProbe->m_NoEleTypes!=0)
     {
         for (unsigned j = 0; j < (unsigned) GetLiveArraySize( ListIndex ); j++)
       {
         Sp=TheArray[ListIndex][j]->SupplyPosition();
         for (unsigned i=0; i<p_TheProbe->m_NoAreas; i++)
         {
           if ((Sp.m_x>=p_TheProbe->m_Rect[i].m_x1)
            && (Sp.m_y>=p_TheProbe->m_Rect[i].m_y1)
            && (Sp.m_x<=p_TheProbe->m_Rect[i].m_x2)
            && (Sp.m_y<=p_TheProbe->m_Rect[i].m_y2))
              for (unsigned k=0; k<p_TheProbe->m_NoEleTypes; k++)
              {
                if (p_TheProbe->m_RefEle[k]==Sp.m_EleType)
                NumberSk++; // it is in the square so increment number
              }
         }
       }
     }
     else
     {
       if (p_TheProbe->m_NoVegTypes!=0)
       {
           for (unsigned j = 0; j<(unsigned)GetLiveArraySize( ListIndex ); j++)
         {
           Sp=TheArray[ListIndex][j]->SupplyPosition();
           for (unsigned i=0; i<p_TheProbe->m_NoAreas; i++)
           {
             if ((Sp.m_x>=p_TheProbe->m_Rect[i].m_x1)
                 && (Sp.m_y>=p_TheProbe->m_Rect[i].m_y1)
                  && (Sp.m_x<=p_TheProbe->m_Rect[i].m_x2)
                   && (Sp.m_y<=p_TheProbe->m_Rect[i].m_y2))
 
             {
               for (unsigned k=0; k<p_TheProbe->m_NoVegTypes; k++)
               {
                 if (p_TheProbe->m_RefVeg[k]==Sp.m_VegType)
                    NumberSk++; // it is in the square so increment number
               }
             }
           }
         }
       }
       else // both must be zero
       {
           for (unsigned j = 0; j<(unsigned)GetLiveArraySize( ListIndex ); j++)
         {
           Sp=TheArray[ListIndex][j]->SupplyPosition();
           for (unsigned i=0; i<p_TheProbe->m_NoAreas; i++)
           {
             if ((Sp.m_x>=p_TheProbe->m_Rect[i].m_x1)
              && (Sp.m_y>=p_TheProbe->m_Rect[i].m_y1)
              && (Sp.m_x<=p_TheProbe->m_Rect[i].m_x2)
              && (Sp.m_y<=p_TheProbe->m_Rect[i].m_y2))
                NumberSk++; // it is in the square so increment number
           }
         }
       }
     }
  }
     return NumberSk;
}

References Bembidion_Egg_List::EggList, Population_Manager::GetLiveArraySize(), AnimalPosition::m_EleType, m_EList, probe_data::m_NoAreas, probe_data::m_NoEleTypes, probe_data::m_NoFarms, probe_data::m_NoVegTypes, probe_data::m_Rect, probe_data::m_RefEle, probe_data::m_RefFarms, probe_data::m_RefVeg, Population_Manager::m_TheLandscape, AnimalPosition::m_VegType, AnimalPosition::m_x, rectangle::m_x1, rectangle::m_x2, AnimalPosition::m_y, rectangle::m_y1, rectangle::m_y2, Landscape::SupplyElementType(), Landscape::SupplyFarmOwner(), Landscape::SupplyVegType(), and Population_Manager::TheArray.

SupplyAdPopSize()

int Bembidion_Population_Manager::SupplyAdPopSize ( )

inline

Get adult population size.

{return m_AdPopSize;}

References m_AdPopSize.

SupplyEDayDeg()

double Bembidion_Population_Manager::SupplyEDayDeg ( int  day )

inline

Get egg day degress for a specific day.

{ return m_EDayDeg[day];}

References m_EDayDeg.

Referenced by Bembidion_Egg_List::st_Develop().

SupplyEggPopSize()

int Bembidion_Population_Manager::SupplyEggPopSize ( )

inline

Get egg population size.

{return m_EPopSize;}

References m_EPopSize.

SupplyLarvaePopSize()

int Bembidion_Population_Manager::SupplyLarvaePopSize ( )

inline

Get larval population size.

{return m_LPopSize;}

References m_LPopSize.

SupplyLDayDeg()

double Bembidion_Population_Manager::SupplyLDayDeg ( int  L, int  day  )

inline

Get larval day degress for a specific dayand instar.

{ return m_LDayDeg[day][L];}

References m_LDayDeg.

Referenced by Bembidion_Larvae::st_Develop().

SupplyPDayDeg()

double Bembidion_Population_Manager::SupplyPDayDeg ( int  day )

inline

Get pupal day degress for a specific day.

{ return m_PDayDeg[day];}

References m_PDayDeg.

Referenced by Bembidion_Pupae::st_Develop().

SupplyPupaePopSize()

int Bembidion_Population_Manager::SupplyPupaePopSize ( )

inline

Get pupal population size.

{return m_PPopSize;}

References m_PPopSize.

TheAOROutputProbe()

void Bembidion_Population_Manager::TheAOROutputProbe ( )

protectedvirtual

Special output functionality.

Reimplemented from Population_Manager.

{
    m_AOR_Probe->DoProbe(bob_Adult);
}

References bob_Adult, AOR_Probe::DoProbe(), and Population_Manager::m_AOR_Probe.

TheReallyBigOutputProbe()

void Bembidion_Population_Manager::TheReallyBigOutputProbe ( )

protectedvirtual

Special output functionality.

Another spatial output method. This time with extra information over and above the x,y, coord found in the Ripley Probe.

Reimplemented from Population_Manager.

                                                             {
  Bembidion_Adult* FS;
  unsigned totalF = (unsigned)GetLiveArraySize( bob_Adult );
  int x,y;
  int w = m_TheLandscape->SupplySimAreaWidth();
  int h = m_TheLandscape->SupplySimAreaWidth();
  fprintf(ReallyBigOutputPrb,"%d %d %d %d %d\n", 0,w ,0, h, totalF);
  for (unsigned j=0; j<totalF; j++)      //adult females
  {
      FS=dynamic_cast<Bembidion_Adult*>(TheArray[3][j]);
      if (FS->GetCurrentStateNo() != -1) {
          x = FS->Supply_m_Location_x();
          y = FS->Supply_m_Location_y();
          int poly = m_TheLandscape->SupplyPolyRef(x, y);
          fprintf(ReallyBigOutputPrb, "%d\t%d\t%d\n", x, y, poly);
      }
  }
  fflush(ReallyBigOutputPrb);
}

References bob_Adult, TALMaSSObject::GetCurrentStateNo(), Population_Manager::GetLiveArraySize(), Population_Manager::m_TheLandscape, Population_Manager::ReallyBigOutputPrb, TAnimal::Supply_m_Location_x(), TAnimal::Supply_m_Location_y(), Landscape::SupplyPolyRef(), Landscape::SupplySimAreaWidth(), and Population_Manager::TheArray.

TheRipleysOutputProbe()

void Bembidion_Population_Manager::TheRipleysOutputProbe ( FILE *  a_prb )

protectedvirtual

Special output functionality.

A spatial output. This dumps the x,y co-ordinates for all adults to a text file.

Reimplemented from Population_Manager.

                                                                      {
  Bembidion_Adult* FS;
  unsigned totalF = (unsigned)(unsigned)GetLiveArraySize( bob_Adult );
  int x,y;
  int w = m_TheLandscape->SupplySimAreaWidth();
  int h = m_TheLandscape->SupplySimAreaWidth();
  fprintf(a_prb,"%d %d %d %d %d\n", 0,w ,0, h, totalF);
  for (unsigned j=0; j<totalF; j++)      //adult females
  {
          FS = dynamic_cast<Bembidion_Adult*>(TheArray[bob_Adult][j]);
          if (FS->GetCurrentStateNo() != -1) {
              x = FS->Supply_m_Location_x();
              y = FS->Supply_m_Location_y();
              fprintf(a_prb, "%d\t%d\n", x, y);
          }
  }
  fflush(a_prb);
}

References bob_Adult, TALMaSSObject::GetCurrentStateNo(), Population_Manager::GetLiveArraySize(), Population_Manager::m_TheLandscape, TAnimal::Supply_m_Location_x(), TAnimal::Supply_m_Location_y(), Landscape::SupplySimAreaWidth(), and Population_Manager::TheArray.

Member Data Documentation

ADDepMort0

int Bembidion_Population_Manager::ADDepMort0

Storage for density-dependent mortality parameter.

Referenced by Bembidion_Population_Manager(), and Bembidion_Adult::DDepMort().

ADDepMort1

double Bembidion_Population_Manager::ADDepMort1

Storage for density-dependent mortality parameter.

Referenced by Bembidion_Population_Manager(), and Bembidion_Adult::DDepMort().

LDDepMort0

int Bembidion_Population_Manager::LDDepMort0

Storage for density-dependent mortality parameter.

Referenced by Bembidion_Population_Manager(), and Bembidion_Larvae::st_Develop().

LDDepMort1

double Bembidion_Population_Manager::LDDepMort1

Storage for density-dependent mortality parameter.

Referenced by Bembidion_Population_Manager(), and Bembidion_Larvae::st_Develop().

m_AdPopSize

int Bembidion_Population_Manager::m_AdPopSize

protected

To store the current population size.

Referenced by DoFirst(), Init(), and SupplyAdPopSize().

m_AdultPosMap

SimplePositionMap* Bembidion_Population_Manager::m_AdultPosMap

Optimsied map of adult positions.

Referenced by Bembidion_Population_Manager(), Bembidion_Adult::DDepMort(), Bembidion_Adult::MoveTo(), Bembidion_Adult::MoveTo_quality_assess(), Bembidion_Adult::MoveToAggr(), Bembidion_Adult::Step(), and ~Bembidion_Population_Manager().

m_EDayDeg

double Bembidion_Population_Manager::m_EDayDeg[365]

protected

Storage for daily day degrees for eggs.

Referenced by Bembidion_Population_Manager(), DoFirst(), and SupplyEDayDeg().

m_EList

Bembidion_Egg_List* Bembidion_Population_Manager::m_EList[365]

Replacement for TheArray[0].

Referenced by Bembidion_Population_Manager(), CreateObjects(), DoBefore(), DoFirst(), Probe(), and ~Bembidion_Population_Manager().

m_EPopSize

int Bembidion_Population_Manager::m_EPopSize

protected

To store the current population size.

Referenced by DoFirst(), Init(), and SupplyEggPopSize().

m_LarvaePosMap

SimplePositionMap* Bembidion_Population_Manager::m_LarvaePosMap

Optimised map of larval positions.

Referenced by Bembidion_Population_Manager(), CreateObjects(), Bembidion_Larvae::st_Develop(), Bembidion_Larvae::st_Pupate(), Bembidion_Larvae::Step(), and ~Bembidion_Population_Manager().

m_LDayDeg

double Bembidion_Population_Manager::m_LDayDeg[365][3]

protected

Storage for daily day degrees for larve.

Referenced by Bembidion_Population_Manager(), DoFirst(), and SupplyLDayDeg().

m_LPopSize

int Bembidion_Population_Manager::m_LPopSize

protected

To store the current population size.

Referenced by DoFirst(), Init(), and SupplyLarvaePopSize().

m_MoveMap

MovementMap* Bembidion_Population_Manager::m_MoveMap

Map of suitability for movement.

Referenced by Bembidion_Population_Manager(), Bembidion_Adult::MoveTo_quality_assess(), Bembidion_Adult::MoveToAggr(), and ~Bembidion_Population_Manager().

m_PDayDeg

double Bembidion_Population_Manager::m_PDayDeg[365]

protected

Storage for daily day degrees for pupae.

Referenced by Bembidion_Population_Manager(), DoFirst(), and SupplyPDayDeg().

m_PPopSize

int Bembidion_Population_Manager::m_PPopSize

protected

To store the current population size.

Referenced by DoFirst(), Init(), and SupplyPupaePopSize().

The_Landscape

Landscape* Bembidion_Population_Manager::The_Landscape

protected

Pointer to the landscape.

TodaysEggProduction

int Bembidion_Population_Manager::TodaysEggProduction

Daily temperature determined egg production.

Referenced by Bembidion_Population_Manager(), Bembidion_Adult::CanReproduce(), and DoFirst().

---

The documentation for this class was generated from the following files:

• /builds/a1mass/almass_stable_oddox/Bembidion/bembidion_all.h
• /builds/a1mass/almass_stable_oddox/Bembidion/Bembidion_all.cpp